package com.taobao.txc.resourcemanager.b.c;

import com.taobao.txc.common.util.c.f;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

public class d
  extends com.taobao.txc.resourcemanager.b.e
{
  public d(Statement paramStatement, com.taobao.txc.resourcemanager.b.a.a parama, String paramString)
  {
    super(paramStatement, parama, paramString);
  }
  
  public ResultSet executeQuery(String paramString)
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.executeQuery(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate(String paramString)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void close()
  {
    try
    {
      super.close();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getMaxFieldSize()
  {
    int i = -1;
    try
    {
      i = super.getMaxFieldSize();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setMaxFieldSize(int paramInt)
  {
    try
    {
      super.setMaxFieldSize(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getMaxRows()
  {
    int i = -1;
    try
    {
      i = super.getMaxRows();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setMaxRows(int paramInt)
  {
    try
    {
      super.setMaxRows(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setEscapeProcessing(boolean paramBoolean)
  {
    try
    {
      super.setEscapeProcessing(paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getQueryTimeout()
  {
    int i = -1;
    try
    {
      i = super.getQueryTimeout();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setQueryTimeout(int paramInt)
  {
    try
    {
      super.setQueryTimeout(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void cancel()
  {
    try
    {
      super.cancel();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public SQLWarning getWarnings()
  {
    SQLWarning localSQLWarning = null;
    try
    {
      localSQLWarning = super.getWarnings();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localSQLWarning;
  }
  
  public void clearWarnings()
  {
    try
    {
      super.clearWarnings();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCursorName(String paramString)
  {
    try
    {
      super.setCursorName(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean execute(String paramString)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public ResultSet getResultSet()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.getResultSet();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int getUpdateCount()
  {
    int i = -1;
    try
    {
      i = super.getUpdateCount();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean getMoreResults()
  {
    boolean bool = false;
    try
    {
      bool = super.getMoreResults();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void setFetchDirection(int paramInt)
  {
    try
    {
      super.setFetchDirection(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getFetchDirection()
  {
    int i = -1;
    try
    {
      i = super.getFetchDirection();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setFetchSize(int paramInt)
  {
    try
    {
      super.setFetchSize(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int getFetchSize()
  {
    int i = -1;
    try
    {
      i = super.getFetchSize();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int getResultSetConcurrency()
  {
    int i = -1;
    try
    {
      i = super.getResultSetConcurrency();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int getResultSetType()
  {
    int i = -1;
    try
    {
      i = super.getResultSetType();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void addBatch(String paramString)
  {
    try
    {
      super.addBatch(paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void clearBatch()
  {
    try
    {
      super.clearBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public int[] executeBatch()
  {
    int[] arrayOfInt = null;
    try
    {
      arrayOfInt = super.executeBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return arrayOfInt;
  }
  
  public Connection getConnection()
  {
    Connection localConnection = null;
    try
    {
      localConnection = super.getConnection();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localConnection;
  }
  
  public boolean getMoreResults(int paramInt)
  {
    boolean bool = false;
    try
    {
      bool = super.getMoreResults(paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public ResultSet getGeneratedKeys()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.getGeneratedKeys();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate(String paramString, int paramInt)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int executeUpdate(String paramString, int[] paramArrayOfInt)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramArrayOfInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public int executeUpdate(String paramString, String[] paramArrayOfString)
  {
    int i = -1;
    try
    {
      i = super.executeUpdate(paramString, paramArrayOfString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean execute(String paramString, int paramInt)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public boolean execute(String paramString, int[] paramArrayOfInt)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramArrayOfInt);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public boolean execute(String paramString, String[] paramArrayOfString)
  {
    boolean bool = false;
    try
    {
      bool = super.execute(paramString, paramArrayOfString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public int getResultSetHoldability()
  {
    int i = -1;
    try
    {
      i = super.getResultSetHoldability();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public boolean isClosed()
  {
    boolean bool = false;
    try
    {
      bool = super.isClosed();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void setPoolable(boolean paramBoolean)
  {
    try
    {
      super.setPoolable(paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean isPoolable()
  {
    boolean bool = false;
    try
    {
      bool = super.isPoolable();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void closeOnCompletion()
  {
    try
    {
      super.closeOnCompletion();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean isCloseOnCompletion()
  {
    boolean bool = false;
    try
    {
      bool = super.isCloseOnCompletion();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public <T> T unwrap(Class<T> paramClass)
  {
    Object localObject = null;
    try
    {
      localObject = super.unwrap(paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localObject;
  }
  
  public boolean isWrapperFor(Class<?> paramClass)
  {
    boolean bool = false;
    try
    {
      bool = super.isWrapperFor(paramClass);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public ResultSet executeQuery()
  {
    ResultSet localResultSet = null;
    try
    {
      localResultSet = super.executeQuery();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSet;
  }
  
  public int executeUpdate()
  {
    int i = -1;
    if (this.a == null) {
      return i;
    }
    try
    {
      int j = this.a.indexOf(';');
      if ((j < 0) || (j == this.a.length() - 1)) {
        return super.executeUpdate();
      }
      List localList = com.taobao.txc.common.util.c.e.a(this.a, c());
      if (localList.size() > 1) {
        for (int k = 0; k < localList.size(); k++)
        {
          f localf = (f)localList.get(k);
          PreparedStatement localPreparedStatement = getConnection().prepareStatement(localf.a);
          for (int m = 0; m < localf.b.length; m++) {
            localPreparedStatement.setObject(m + 1, localf.b[m].get(0));
          }
          try
          {
            i = localPreparedStatement.executeUpdate();
          }
          finally
          {
            localPreparedStatement.close();
          }
        }
      } else {
        i = super.executeUpdate();
      }
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return i;
  }
  
  public void setNull(int paramInt1, int paramInt2)
  {
    try
    {
      super.setNull(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBoolean(int paramInt, boolean paramBoolean)
  {
    try
    {
      super.setBoolean(paramInt, paramBoolean);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setByte(int paramInt, byte paramByte)
  {
    try
    {
      super.setByte(paramInt, paramByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setShort(int paramInt, short paramShort)
  {
    try
    {
      super.setShort(paramInt, paramShort);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setInt(int paramInt1, int paramInt2)
  {
    try
    {
      super.setInt(paramInt1, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setLong(int paramInt, long paramLong)
  {
    try
    {
      super.setLong(paramInt, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setFloat(int paramInt, float paramFloat)
  {
    try
    {
      super.setFloat(paramInt, paramFloat);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDouble(int paramInt, double paramDouble)
  {
    try
    {
      super.setDouble(paramInt, paramDouble);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBigDecimal(int paramInt, BigDecimal paramBigDecimal)
  {
    try
    {
      super.setBigDecimal(paramInt, paramBigDecimal);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setString(int paramInt, String paramString)
  {
    try
    {
      super.setString(paramInt, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBytes(int paramInt, byte[] paramArrayOfByte)
  {
    try
    {
      super.setBytes(paramInt, paramArrayOfByte);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setDate(int paramInt, Date paramDate)
  {
    try
    {
      super.setDate(paramInt, paramDate);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(int paramInt, Time paramTime)
  {
    try
    {
      super.setTime(paramInt, paramTime);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(int paramInt, Timestamp paramTimestamp)
  {
    try
    {
      super.setTimestamp(paramInt, paramTimestamp);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setAsciiStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setUnicodeStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setUnicodeStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt1, InputStream paramInputStream, int paramInt2)
  {
    try
    {
      super.setBinaryStream(paramInt1, paramInputStream, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void clearParameters()
  {
    try
    {
      super.clearParameters();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt1, Object paramObject, int paramInt2)
  {
    try
    {
      super.setObject(paramInt1, paramObject, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt, Object paramObject)
  {
    try
    {
      super.setObject(paramInt, paramObject);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public boolean execute()
  {
    boolean bool = false;
    try
    {
      bool = super.execute();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return bool;
  }
  
  public void addBatch()
  {
    try
    {
      super.addBatch();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt1, Reader paramReader, int paramInt2)
  {
    try
    {
      super.setCharacterStream(paramInt1, paramReader, paramInt2);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setRef(int paramInt, Ref paramRef)
  {
    try
    {
      super.setRef(paramInt, paramRef);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, Blob paramBlob)
  {
    try
    {
      super.setBlob(paramInt, paramBlob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Clob paramClob)
  {
    try
    {
      super.setClob(paramInt, paramClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setArray(int paramInt, Array paramArray)
  {
    try
    {
      super.setArray(paramInt, paramArray);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public ResultSetMetaData getMetaData()
  {
    ResultSetMetaData localResultSetMetaData = null;
    try
    {
      localResultSetMetaData = super.getMetaData();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localResultSetMetaData;
  }
  
  public void setDate(int paramInt, Date paramDate, Calendar paramCalendar)
  {
    try
    {
      super.setDate(paramInt, paramDate, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTime(int paramInt, Time paramTime, Calendar paramCalendar)
  {
    try
    {
      super.setTime(paramInt, paramTime, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setTimestamp(int paramInt, Timestamp paramTimestamp, Calendar paramCalendar)
  {
    try
    {
      super.setTimestamp(paramInt, paramTimestamp, paramCalendar);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNull(int paramInt1, int paramInt2, String paramString)
  {
    try
    {
      super.setNull(paramInt1, paramInt2, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setURL(int paramInt, URL paramURL)
  {
    try
    {
      super.setURL(paramInt, paramURL);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public ParameterMetaData getParameterMetaData()
  {
    ParameterMetaData localParameterMetaData = null;
    try
    {
      localParameterMetaData = super.getParameterMetaData();
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
    return localParameterMetaData;
  }
  
  public void setRowId(int paramInt, RowId paramRowId)
  {
    try
    {
      super.setRowId(paramInt, paramRowId);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNString(int paramInt, String paramString)
  {
    try
    {
      super.setNString(paramInt, paramString);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNCharacterStream(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, NClob paramNClob)
  {
    try
    {
      super.setNClob(paramInt, paramNClob);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setClob(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBlob(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setNClob(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setSQLXML(int paramInt, SQLXML paramSQLXML)
  {
    try
    {
      super.setSQLXML(paramInt, paramSQLXML);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setObject(int paramInt1, Object paramObject, int paramInt2, int paramInt3)
  {
    try
    {
      super.setObject(paramInt1, paramObject, paramInt2, paramInt3);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setAsciiStream(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt, InputStream paramInputStream, long paramLong)
  {
    try
    {
      super.setBinaryStream(paramInt, paramInputStream, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt, Reader paramReader, long paramLong)
  {
    try
    {
      super.setCharacterStream(paramInt, paramReader, paramLong);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setAsciiStream(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setAsciiStream(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBinaryStream(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setBinaryStream(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setCharacterStream(int paramInt, Reader paramReader)
  {
    try
    {
      super.setCharacterStream(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNCharacterStream(int paramInt, Reader paramReader)
  {
    try
    {
      super.setNCharacterStream(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setClob(int paramInt, Reader paramReader)
  {
    try
    {
      super.setClob(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setBlob(int paramInt, InputStream paramInputStream)
  {
    try
    {
      super.setBlob(paramInt, paramInputStream);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
  
  public void setNClob(int paramInt, Reader paramReader)
  {
    try
    {
      super.setNClob(paramInt, paramReader);
    }
    catch (Throwable localThrowable)
    {
      a.b(e(), localThrowable);
    }
  }
}


/* Location:           C:\Users\ibm\Downloads\txc-yun-sample (1)\txc-yun-sample\lib\txc-client-2.0.72.jar
 * Qualified Name:     com.taobao.txc.resourcemanager.b.c.d
 * JD-Core Version:    0.7.0.1
 */